5.02. Flask

В РАЗРАБОТКЕНЕ ДЛЯ НОВИЧКОВНЕ ОБЯЗАТЕЛЬНО

Разработчику Архитектору

Flask

Flask — это веб-фреймворк для языка программирования Python. Он предоставляет инструменты и библиотеки, необходимые для создания веб-приложений любого масштаба — от простых демонстрационных сервисов до сложных распределённых систем. Flask принадлежит к категории так называемых микрофреймворков, что означает минимальный набор встроенных компонентов и максимальную гибкость в выборе сторонних решений. Эта характеристика делает Flask особенно подходящим для образовательных целей, прототипирования и проектов, где важна прозрачность архитектуры.

Исторический контекст и происхождение

Flask был создан Армином Ронахером (Armin Ronacher) в 2010 году как экспериментальный проект внутри сообщества Pocoo — группы разработчиков, известной своими вкладами в экосистему Python. Первоначальная цель заключалась в создании альтернативы существующим фреймворкам, таким как Django, но с меньшим количеством предположений о структуре приложения и большей степенью контроля у разработчика. Flask быстро завоевал популярность благодаря своей простоте, читаемости кода и модульности.

Фреймворк основан на двух ключевых компонентах: Werkzeug и Jinja. Werkzeug — это WSGI-утилита (Web Server Gateway Interface), которая обеспечивает низкоуровневую обработку HTTP-запросов и ответов. Jinja — это шаблонизатор, позволяющий генерировать HTML-страницы динамически, подставляя данные из Python-кода. Оба компонента разработаны тем же автором и тесно интегрированы во Flask, но остаются независимыми проектами, которые можно использовать отдельно.

Философия проектирования

Flask следует принципу «не навязывай, а предлагай». Он не диктует структуру проекта, не требует использования определённой базы данных, не включает ORM (Object-Relational Mapping) по умолчанию и не принуждает к применению конкретного способа аутентификации или управления сессиями. Вместо этого Flask предоставляет базовый каркас, на который разработчик самостоятельно «нанизывает» нужные компоненты.

Эта философия выражается в нескольких ключевых идеях:

Минимализм: ядро Flask содержит только то, что необходимо для маршрутизации запросов и формирования ответов.
Расширяемость: через систему расширений (Flask extensions) можно легко добавить поддержку баз данных, форм, почты, авторизации и других функций.
Явность конфигурации: поведение приложения определяется явными настройками, а не скрытыми соглашениями.
Согласованность с Python: Flask стремится сохранять идиоматический стиль языка Python, делая код интуитивно понятным даже новичкам.

Такой подход позволяет разработчику принимать осознанные архитектурные решения, а не следовать заранее заданному шаблону. Это особенно ценно в учебных проектах, где важно понимать, как устроены веб-приложения «под капотом».

Базовые концепции Flask

Приложение (Application)

В Flask каждое веб-приложение начинается с создания экземпляра класса Flask. Этот объект служит центральной точкой управления: он хранит маршруты, обработчики ошибок, конфигурацию и состояние приложения. Пример минимального приложения выглядит так:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return "Привет, мир!"

if __name__ == '__main__':
    app.run()

Здесь переменная app представляет собой само приложение. Декоратор @app.route связывает URL-путь с функцией-обработчиком. Когда пользователь обращается к корневому пути (/), вызывается функция home, и её возвращаемое значение отправляется клиенту в виде HTTP-ответа.

Маршрутизация (Routing)

Маршрутизация — это механизм сопоставления URL-адресов с функциями, которые их обрабатывают. Flask использует декораторы для привязки маршрутов, что делает код наглядным и компактным. Помимо статических путей, Flask поддерживает динамические сегменты, называемые переменными пути. Например:

@app.route('/user/<username>')
def show_user_profile(username):
    return f'Профиль пользователя: {username}'

В этом примере <username> — это переменная, значение которой извлекается из URL и передаётся в функцию как аргумент. Flask автоматически преобразует её в строку, но можно указать тип, например <int:user_id>, чтобы гарантировать числовое значение.

Маршрутизация в Flask основана на дереве путей и поддерживает методы HTTP (GET, POST, PUT, DELETE и другие). По умолчанию маршрут отвечает только на GET-запросы, но можно явно указать список допустимых методов:

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        # обработка формы входа
        pass
    else:
        # отображение формы
        pass

Контексты запроса и приложения

Одна из важнейших, но часто упускаемых из виду особенностей Flask — это система контекстов. Поскольку веб-приложение одновременно обслуживает множество запросов, Flask должен обеспечивать изоляцию данных между ними. Для этого используются два типа контекстов:

Контекст запроса (Request Context) — содержит информацию о текущем HTTP-запросе: заголовки, тело, параметры, cookies и другие атрибуты. Объект request доступен только внутри этого контекста.
Контекст приложения (Application Context) — хранит глобальные данные, относящиеся ко всему приложению, такие как конфигурация или подключение к базе данных. Он существует дольше, чем контекст запроса, и может использоваться вне обработчиков, например в фоновых задачах.

Эти контексты управляются автоматически при запуске приложения через встроенный сервер или WSGI-сервер, но при тестировании или выполнении вне HTTP-цикла их нужно активировать вручную с помощью менеджеров контекста (with app.app_context():).

Шаблоны и рендеринг

Flask включает в себя шаблонизатор Jinja, который позволяет отделять логику приложения от представления. Шаблоны — это HTML-файлы с встроенными элементами динамики: переменными, условиями, циклами и наследованием. Например:

<!-- templates/index.html -->
<!DOCTYPE html>
<html>
<head><title>{{ title }}</title></head>
<body>
    <h1>Добро пожаловать, {{ name }}!</h1>
</body>
</html>

В обработчике используется функция render_template, которая загружает шаблон и подставляет в него данные:

from flask import render_template

@app.route('/hello/<name>')
def hello(name):
    return render_template('index.html', title='Приветствие', name=name)

Jinja обеспечивает автоматическое экранирование HTML по умолчанию, что защищает от XSS-атак. Также поддерживаются макросы, фильтры и наследование шаблонов, что позволяет строить сложные иерархии страниц с минимальным дублированием кода.

Обработка запросов и ответов

Flask предоставляет объекты request и response, которые инкапсулируют входящие и исходящие данные HTTP-транзакции. Объект request содержит все сведения о запросе: метод, URL, заголовки, параметры строки запроса (?key=value), тело (например, данные формы или JSON), cookies и файлы. Доступ к этим данным осуществляется через атрибуты:

request.args — параметры из строки запроса,
request.form — данные, отправленные через HTML-форму методом POST,
request.json — тело запроса в формате JSON,
request.files — загруженные файлы,
request.cookies — cookies, присланные браузером.

Объект ответа формируется автоматически на основе возвращаемого значения обработчика. Если функция возвращает строку, Flask оборачивает её в объект Response с MIME-типом text/html. Можно явно создавать ответы с помощью функции make_response, чтобы установить статус-код, заголовки или cookies:

from flask import make_response

@app.route('/cookie')
def set_cookie():
    resp = make_response("Cookie установлен")
    resp.set_cookie('user_id', '12345')
    return resp

Также Flask поддерживает возврат кортежей вида (тело, статус, заголовки), что упрощает формирование нестандартных ответов без импорта дополнительных функций.

Сессии и состояние

Веб-протокол HTTP по своей природе не сохраняет состояние между запросами. Чтобы преодолеть это ограничение, Flask реализует механизм сессий на основе подписанных cookies. Сессия — это словарь, который хранится на стороне клиента, но защищён криптографической подписью, чтобы предотвратить подделку. Для работы сессий необходимо задать секретный ключ приложения:

app.secret_key = 'секретный_ключ_для_подписи'

После этого можно использовать объект session как обычный словарь:

from flask import session

@app.route('/login', methods=['POST'])
def login():
    session['username'] = request.form['username']
    return "Вы вошли в систему"

@app.route('/profile')
def profile():
    if 'username' in session:
        return f"Профиль: {session['username']}"
    return "Пожалуйста, войдите"

Сессии удобны для хранения небольших фрагментов данных, таких как идентификатор пользователя или настройки интерфейса. Для более объёмной информации рекомендуется использовать серверное хранилище (например, базу данных), а в сессии оставлять только идентификатор сессии.

Расширения и экосистема

Одно из главных преимуществ Flask — его богатая экосистема расширений. Расширение — это пакет Python, который интегрируется с Flask и добавляет новую функциональность. Некоторые из самых популярных:

Flask-SQLAlchemy — интеграция с ORM SQLAlchemy для работы с реляционными базами данных.
Flask-WTF — поддержка форм с валидацией и защитой от CSRF-атак.
Flask-Login — управление аутентификацией пользователей.
Flask-Mail — отправка электронной почты.
Flask-Migrate — миграции базы данных через Alembic.
Flask-CORS — поддержка Cross-Origin Resource Sharing для API.

Расширения следуют единому соглашению: они принимают объект приложения в качестве аргумента и регистрируют свои компоненты в его контексте. Многие расширения также поддерживают отложенную инициализацию через метод init_app, что позволяет использовать их в модульных приложениях и при тестировании.

Организация проекта

Flask не навязывает структуру каталогов, но существуют общепринятые практики. Для небольших приложений достаточно одного файла (app.py). По мере роста проекта применяют один из двух подходов:

Модульный стиль: код разбивается на несколько Python-модулей (например, models.py, views.py, forms.py), но всё ещё находится в одном каталоге.
Пакетный стиль (Application Factory): приложение создаётся внутри функции, что позволяет гибко управлять конфигурацией и избегать циклических импортов. Этот подход особенно важен при написании тестов и развёртывании в разных окружениях (разработка, тестирование, продакшен).

Пример структуры пакетного проекта:

myproject/
├── app/
│   ├── __init__.py          # фабрика приложения
│   ├── models.py            # модели данных
│   ├── routes.py            # маршруты
│   ├── templates/           # шаблоны
│   └── static/              # статические файлы (CSS, JS, изображения)
├── config.py                # конфигурация
├── run.py                   # точка запуска
└── requirements.txt         # зависимости

Файл __init__.py содержит функцию create_app, которая инициализирует Flask и регистрирует все компоненты:

# app/__init__.py
from flask import Flask

def create_app():
    app = Flask(__name__)
    app.config.from_object('config.DevelopmentConfig')

    from .routes import main as main_blueprint
    app.register_blueprint(main_blueprint)

    return app

Этот подход обеспечивает чистоту архитектуры и совместимость с современными инструментами развёртывания, такими как Gunicorn или uWSGI.

Тестирование

Flask включает встроенные средства для модульного тестирования. Клиент тестирования (test_client) имитирует HTTP-запросы без запуска реального сервера, что позволяет быстро проверять логику маршрутов, обработку форм и работу с базой данных. Пример простого теста:

import unittest
from app import create_app

class BasicTestCase(unittest.TestCase):
    def setUp(self):
        self.app = create_app()
        self.client = self.app.test_client()

    def test_home_page(self):
        response = self.client.get('/')
        self.assertEqual(response.status_code, 200)
        self.assertIn(b'Привет', response.data)

Для изоляции тестов часто используют временные базы данных в памяти (например, SQLite) и фикстуры, которые подготавливают начальное состояние перед каждым тестом.

Конфигурация приложения

Конфигурация — это механизм управления параметрами приложения в зависимости от окружения: разработка, тестирование, производственная эксплуатация. Flask хранит все настройки в атрибуте app.config, который представляет собой словарь с дополнительными методами загрузки. Существует несколько способов задать конфигурацию:

Прямое присваивание:

app.config['DEBUG'] = True
app.config['SECRET_KEY'] = 'ключ'

Загрузка из Python-класса:

class Config:
    SECRET_KEY = 'ключ'
    SQLALCHEMY_DATABASE_URI = 'sqlite:///app.db'

class ProductionConfig(Config):
    DEBUG = False

app.config.from_object(ProductionConfig)

Загрузка из файла:
```
app.config.from_pyfile('config.py')
```
Загрузка из переменных окружения:
```
app.config.from_envvar('FLASK_CONFIG')
```

Использование классов позволяет создавать иерархию конфигураций с наследованием общих параметров. Это особенно полезно, когда нужно поддерживать разные настройки для локальной машины, CI-сервера и облачного хостинга. Важно никогда не хранить секретные данные (пароли, ключи API) в коде репозитория — они должны передаваться через переменные окружения или защищённые файлы, исключённые из системы контроля версий.

Обработка ошибок

Flask предоставляет гибкие инструменты для перехвата и обработки HTTP-ошибок и исключений. Можно зарегистрировать функцию-обработчик для конкретного статус-кода с помощью декоратора @app.errorhandler:

@app.errorhandler(404)
def page_not_found(e):
    return render_template('404.html'), 404

Аналогично можно обрабатывать любые исключения Python:

@app.errorhandler(ValueError)
def handle_value_error(e):
    return "Некорректные данные", 400

Обработчики ошибок могут возвращать HTML-страницы, JSON-ответы или перенаправления, что делает их универсальными для веб-сайтов и API. При разработке полезно включать режим отладки (DEBUG = True), который показывает подробный трейсбэк ошибки прямо в браузере. В продакшене этот режим обязательно отключают, чтобы не раскрывать внутреннюю структуру приложения.

Работа со статическими файлами

Статические файлы — это CSS, JavaScript, изображения, шрифты и другие ресурсы, которые не генерируются динамически. Flask автоматически обслуживает такие файлы из каталога static в корне проекта. Например, файл static/style.css будет доступен по адресу /static/style.css. В шаблонах используется функция url_for для генерации правильных путей:

<link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">

Этот подход обеспечивает устойчивость к изменениям структуры URL и поддерживает кэширование. Для больших проектов часто подключают внешние CDN или используют сборщики (например, Webpack), но Flask остаётся нейтральным к выбору инструментов фронтенда.

Разработка RESTful API

Хотя Flask изначально создавался для веб-сайтов, он отлично подходит для построения RESTful API. Для этого достаточно возвращать данные в формате JSON вместо HTML. Flask предоставляет функцию jsonify, которая преобразует словарь Python в JSON-ответ с правильным MIME-типом:

from flask import jsonify

@app.route('/api/users/<int:user_id>')
def get_user(user_id):
    user = {'id': user_id, 'name': 'Иван'}
    return jsonify(user)

При построении полноценного API рекомендуется использовать расширение Flask-RESTful или Flask-API, которые упрощают сериализацию, валидацию и документирование. Однако даже без них Flask позволяет создавать чистые, соответствующие стандартам интерфейсы благодаря своей гибкости и минимализму.

Безопасность

Безопасность веб-приложений — это многоуровневая задача, и Flask предоставляет базовые средства защиты:

Защита от CSRF — через расширение Flask-WTF, которое генерирует и проверяет токены в формах.
Экранирование вывода — Jinja автоматически экранирует переменные в шаблонах, предотвращая XSS.
Безопасные cookies — сессии подписываются секретным ключом, а опционально можно включить флаги HttpOnly и Secure.
Заголовки безопасности — через middleware или расширения можно добавлять заголовки Content-Security-Policy, X-Frame-Options, Strict-Transport-Security.

Разработчик несёт ответственность за применение этих механизмов и за регулярное обновление зависимостей. Flask сам по себе не содержит уязвимостей, но неправильное использование может привести к рискам.

Производительность и масштабируемость

Встроенный сервер Flask (app.run()) предназначен только для разработки. Он однопоточный и не выдерживает высокой нагрузки. Для продакшена приложение развёртывают через WSGI-сервер, такой как Gunicorn, uWSGI или mod_wsgi (для Apache). Эти серверы поддерживают многопроцессность, балансировку и интеграцию с обратными прокси (Nginx, Apache).

Масштабируемость Flask-приложений достигается за счёт:

горизонтального масштабирования (запуск нескольких экземпляров),
кэширования (через Redis или Memcached),
асинхронной обработки тяжёлых задач (через Celery или RQ),
оптимизации базы данных и запросов.

Flask не накладывает ограничений на архитектуру, поэтому его можно интегрировать в микросервисные системы, serverless-платформы (AWS Lambda, Google Cloud Functions) и контейнерные среды (Docker, Kubernetes).

Flask​

Исторический контекст и происхождение​

Философия проектирования​

Базовые концепции Flask​

Приложение (Application)​

Маршрутизация (Routing)​

Контексты запроса и приложения​

Шаблоны и рендеринг​

Обработка запросов и ответов​

Сессии и состояние​

Расширения и экосистема​

Организация проекта​

Тестирование​

Конфигурация приложения​

Обработка ошибок​

Работа со статическими файлами​

Разработка RESTful API​

Безопасность​

Производительность и масштабируемость​